package com.totoro.tyrank.utils;

import com.totoro.tyrank.TyRank;
import com.totoro.tyrank.constants.StaticSystemVarConst;
import org.bukkit.Bukkit;
import org.bukkit.Color;

import java.text.ParseException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DateUtil {


    /**
     * 将秒数转换为天时分秒格式的字符串
     * @param totalSeconds 总秒数
     * @return 格式化后的时间字符串，如"1天2时3分4秒"
     */
    public static String formatSeconds(int totalSeconds) {
        // 处理负数情况
        if (totalSeconds < 0) {
            return "0秒";
        }

        // 计算各时间单位
        int days = totalSeconds / 86400; // 1天 = 86400秒
        int remainingSeconds = totalSeconds % 86400;

        int hours = remainingSeconds / 3600; // 1小时 = 3600秒
        remainingSeconds %= 3600;

        int minutes = remainingSeconds / 60; // 1分钟 = 60秒
        int seconds = remainingSeconds % 60;

        // 构建结果字符串
        StringBuilder sb = new StringBuilder();

        if (days > 0) {
            sb.append(days).append("天");
        }
        if (hours > 0) {
            sb.append(hours).append("时");
        }
        if (minutes > 0) {
            sb.append(minutes).append("分");
        }
        if (seconds > 0) {
            sb.append(seconds).append("秒");
        }

        // 处理所有单位都为0的情况
        if (sb.length() == 0) {
            sb.append("0秒");
        }

        return sb.toString();
    }

    /**
     * 计算指定时间与当前时间的差值
     * @param timeStr 格式为yyyy-MM-dd HH:mm:ss的时间字符串
     * @return 若时间已过则返回"已结束"，否则返回剩余时间字符串（如1天1时1分1秒）
     */
    public static String getTimeDifference(String timeStr) {
        try {
            // 解析输入的时间字符串
            Date targetTime = StaticSystemVarConst.SIMPLE_DATE_FORMATTER.parse(timeStr);
            // 获取当前时间
            Date now = new Date();

            // 如果目标时间在当前时间之前，返回"已结束"
            if (targetTime.before(now)) {
                return "已结束";
            }

            // 计算时间差（毫秒）
            long diffMillis = targetTime.getTime() - now.getTime();

            // 转换为天、时、分、秒
            long days = TimeUnit.MILLISECONDS.toDays(diffMillis);
            long hours = TimeUnit.MILLISECONDS.toHours(diffMillis) % 24;
            long minutes = TimeUnit.MILLISECONDS.toMinutes(diffMillis) % 60;
            long seconds = TimeUnit.MILLISECONDS.toSeconds(diffMillis) % 60;

            // 构建结果字符串
            StringBuilder sb = new StringBuilder();
            if (days > 0) {
                sb.append(days).append("天");
            }
            if (hours > 0) {
                sb.append(hours).append("时");
            }
            if (minutes > 0) {
                sb.append(minutes).append("分");
            }
            if (seconds > 0) {
                sb.append(seconds).append("秒");
            }

            // 如果所有值都为0（理论上不会发生，因为已判断过时间顺序）
            return sb.length() > 0 ? sb.toString() : "0秒";

        } catch (ParseException e) {
            // 处理时间格式解析错误
            return "时间格式错误";
        }
    }

    /**
     * 时间字符串转LocalDateTime
     * @param keyword
     * @return
     */
    public static LocalDateTime strFormatDate(String keyword) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(TyRank.getConfigManager().getConfigData().getDateFormat());

        try {
            // 先转换为 LocalDateTime（Java 8+ 新日期类）
            return LocalDateTime.parse(keyword, formatter);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("日期格式解析错误！");
        }
        return null;
    }

    /**
     * LocalDateTime转字符串
     * @param localDateTime
     * @return
     */
    public static String dateFormatStr(LocalDateTime localDateTime) {
        return localDateTime.format(StaticSystemVarConst.DATE_FORMATTER);
    }

    public static String currentDateStr() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(TyRank.getConfigManager().getConfigData().getDateFormat()));
    }

    public static LocalDateTime currentDate() {
        return LocalDateTime.now();
    }

    /**
     * 判断当前时间是否大于指定的时间字符串
     * @param timeStr 时间字符串，格式为 yyyy-MM-dd HH:mm:ss
     * @return 如果当前时间晚于指定时间返回true，否则返回false（解析失败也返回false）
     */
    public static boolean isCurrentTimeAfter(String timeStr) {
        // 定义时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(TyRank.getConfigManager().getConfigData().getDateFormat());

        try {
            // 解析字符串为LocalDateTime
            LocalDateTime targetTime = LocalDateTime.parse(timeStr, formatter);

            // 获取当前时间
            LocalDateTime currentTime = LocalDateTime.now();

            // 比较当前时间是否在目标时间之后
            return currentTime.isAfter(targetTime);
        } catch (DateTimeParseException e) {
            // 处理时间格式解析错误
            Bukkit.getServer().getConsoleSender().sendMessage(StaticSystemVarConst.CONSOLE_PREFIX + ColorUtil.color("时间格式解析错误: " + timeStr));
            e.printStackTrace();
            return false;
        }
    }

    public static boolean isCurrentTimeAfter(LocalDateTime time) {
        return isCurrentTimeAfter(time.format(StaticSystemVarConst.DATE_FORMATTER));
    }

    /**
     * 判断当前时间是否比指定时间字符串超出目标秒数
     * @param timeStr 时间字符串，格式为 yyyy-MM-dd HH:mm:ss
     * @param targetSeconds 目标秒数
     * @return 如果当前时间 - 目标时间 > targetSeconds 则返回true，否则返回false（解析失败也返回false）
     */
    public static boolean isTimeExceeded(String timeStr, long targetSeconds) {
        if(targetSeconds == -1L) {
            return false;
        }
        // 定义时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(TyRank.getConfigManager().getConfigData().getDateFormat());

        try {
            // 解析字符串为LocalDateTime
            LocalDateTime targetTime = LocalDateTime.parse(timeStr, formatter);

            // 获取当前时间
            LocalDateTime currentTime = LocalDateTime.now();

            // 计算当前时间与目标时间的秒数差（如果当前时间在目标时间之前，差值为负）
            long secondsDiff = ChronoUnit.SECONDS.between(targetTime, currentTime);

            // 判断差值是否大于目标秒数
            return secondsDiff > targetSeconds;
        } catch (DateTimeParseException e) {
            System.err.println("时间格式解析错误: " + timeStr);
            e.printStackTrace();
            return false;
        }
    }

}
